home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK1.toast / Development Kits (Disc 1) / AOCE / Development Tools / Interfaces / PInterfaces / OCEStandardDirectory.p < prev    next >
Encoding:
Text File  |  1993-11-10  |  19.0 KB  |  674 lines  |  [TEXT/MPS ]
  1. {***********************************************************
  2.  
  3. Created: Monday, November 8, 1993 11:59AM
  4.  OCEStandardDirectory.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.   Copyright Apple Computer, Inc. 1990-1993
  8.   All rights reserved
  9.  
  10. ***********************************************************}
  11.  
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes:= 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.     UNIT OCEStandardDirectory;
  19.     INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED UsingOCEStandardDirectory}
  23. {$SETC UsingOCEStandardDirectory:= 1}
  24.  
  25. {$I+}
  26. {$SETC OCEStandardDirectoryIncludes:= UsingIncludes}
  27. {$SETC UsingIncludes:= 1}
  28.  
  29.  
  30. {$IFC UNDEFINED UsingOCE}
  31. {$I OCE.p}
  32. {$ENDC}
  33.  
  34. {$IFC UNDEFINED UsingOCEAuthDir}
  35. {$I OCEAuthDir.p}
  36. {$ENDC}
  37.  
  38. {$IFC UNDEFINED UsingTypes}
  39. {$I $$Shell(PInterfaces)Types.p}
  40. {$ENDC}
  41.  
  42. {$IFC UNDEFINED UsingWindows}
  43. {$I $$Shell(PInterfaces)Windows.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED UsingIcons}
  47. {$I $$Shell(PInterfaces)Icons.p}
  48. {$ENDC}
  49.  
  50. {$SETC UsingIncludes:= OCEStandardDirectoryIncludes}
  51.  
  52.  
  53.  
  54. { CollabPack Trap Selectors }
  55.  
  56. CONST
  57. kSDPNewPanel                    = 100;
  58. kSDPGetNewPanel                    = 101;
  59. kSDPDisposePanel                = 102;
  60. kSDPHidePanel                    = 103;
  61. kSDPShowPanel                    = 104;
  62. kSDPEnablePanel                    = 105;
  63. kSDPUpdatePanel                    = 106;
  64. kSDPMovePanel                    = 107;
  65. kSDPSizePanel                    = 108;
  66. kSDPOpenSelectedItem            = 109;
  67. kSDPGetPanelSelectionState        = 110;
  68. kSDPGetPanelSelection            = 111;
  69. kSDPSetPath                        = 112;
  70. kSDPPanelEvent                    = 113;
  71. kSDPGetPanelSelectionSize        = 114;
  72. kSDPSetIdentity                    = 115;
  73. kSDPSelectString                = 116;
  74. kSDPGetPathLength                = 117;
  75. kSDPGetPath                        = 118;
  76. kSDPSetFocus                    = 119;
  77. kSDPSetPanelBalloonHelp            = 120;
  78. kSDPInstallPanelBusyProc        = 121;
  79.  
  80. kSDPPromptForID                    = 904;
  81.  
  82. kSDPNewFindPanel                = 2300;
  83. kSDPDisposeFindPanel            = 2301;
  84. kSDPStartFind                    = 2302;
  85. kSDPStopFind                    = 2303;
  86. kSDPFindPanelEvent                = 2304;
  87. kSDPDrawFindPanel                = 2305;
  88. kSDPShowFindPanel                = 2306;
  89. kSDPHideFindPanel                = 2307;
  90. kSDPMoveFindPanel                = 2308;
  91. kSDPEnableFindPanel                = 2309;
  92. kSDPSetFindPanelFocus            = 2310;
  93. kSDPGetFindPanelState            = 2311;
  94. kSDPGetFindPanelSelectionSize    = 2312;
  95. kSDPGetFindPanelSelection        = 2313;
  96. kSDPSetFindPanelBalloonHelp        = 2314;
  97. kSDPSetFindIdentity                = 2315;
  98. kSDPInstallFindPanelBusyProc    = 2316;
  99.  
  100. kSDPGetIconByType                = 1024;
  101. kSDPGetDSSpecIcon                = 1025;
  102. kSDPGetCategories                = 1026;
  103. kSDPGetCategoryTypes            = 1027;
  104.  
  105. kSDPResolveAliasFile            = 3700;
  106. kSDPResolveAliasDSSpec            = 3701;
  107.  
  108. kSDPRepairPersonalDirectory        = 6700;
  109.  
  110.  
  111.  
  112. { Collaboration Package Gestalts. }
  113.  
  114. gestaltSDPStandardDirectoryVersion    = 'sdvr';
  115. gestaltSDPFindVersion                = 'dfnd';
  116. gestaltSDPPromptVersion                = 'prpv';
  117.  
  118.  
  119.  
  120. {$IFC UNDEFINED svLarge1Bit}
  121. {  Selector mask values  }
  122. { This is temporary. It will eventually appear in Icons.h }
  123.  
  124. TYPE
  125. IconSelectorValue = LONGINT;
  126.  
  127.  
  128. CONST
  129. svLarge1Bit            = $00000001;
  130. svLarge4Bit            = $00000002;
  131. svLarge8Bit            = $00000004;
  132. svSmall1Bit            = $00000100;
  133. svSmall4Bit            = $00000200;
  134. svSmall8Bit            = $00000400;
  135. svMini1Bit            = $00010000;
  136. svMini4Bit            = $00020000;
  137. svMini8Bit            = $00040000;
  138. svAllLargeData        = $000000ff;
  139. svAllSmallData        = $0000ff00;
  140. svAllMiniData        = $00ff0000;
  141. svAll1BitData        = (svLarge1Bit + svSmall1Bit + svMini1Bit);
  142. svAll4BitData        = (svLarge4Bit + svSmall4Bit + svMini4Bit);
  143. svAll8BitData        = (svLarge8Bit + svSmall8Bit + svMini8Bit);
  144. svAllAvailableData    = $ffffffff;
  145. {$ENDC}
  146.  
  147.  
  148. { generic icon suites }
  149. CONST
  150. genericDirectoryIconResource            = -16721;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  151. genericLockedDirectoryIconResource        = -16716;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  152. genericRecordIconResource                = -16722;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  153. genericAttributeIconResource            = -16723;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  154. genericTemplateIconResource                = -16746;    { icl8, icl4, ICN#, ics#, ics4, ics8 }
  155.  
  156. { standard icon suites }
  157.  
  158. directoryFolderIconResource                = -16720;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  159. lockedDirectoryFolderIconResource        = -16719;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  160. personalDirectoryIconResource            = -16718;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  161. directoriesIconResource                    = -16717;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  162. preferredPersonalDirectoryIconResource    = -16724;    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  163.  
  164. { icon IDs for spinning arrows }
  165. kFirstSpinnerIcon                        = -16745;
  166. kLastSpinnerIcon                        = -16738;
  167.  
  168.  
  169. { resource types }
  170. kSDPPanelResourceType                    = 'panl';
  171. kSDPFindPanelResourceType                = 'find';
  172.  
  173. { Standard FindPanel resource }
  174. kStandardFindLayout                        = -16700;
  175.  
  176. { Values of SDPMatchWith }
  177. kSDPMatchAll                            = 0;
  178. kSDPExactMatch                            = 256;
  179. kSDPBeginsWith                            = 512;
  180. kSDPEndingWith                            = 1024;
  181. kSDPContaining                            = 2048;
  182.  
  183. TYPE
  184. SDPMatchWith = INTEGER;
  185.  
  186. { Prompt For Identity structures }
  187. CONST
  188. kSDPGuestBit = 0;
  189. kSDPSpecificIdentityBit = 1;
  190. kSDPLocalIdentityBit = 2;
  191.  
  192. { Values of SDPIdentityKind }
  193. kSDPGuestMask                 = $0001;  {1<<kSDPGuestBit}
  194. kSDPSpecificIdentityMask     = $0002;  {1<<kSDPSpecificIdentityBit}
  195. kSDPLocalIdentityMask         = $0004;  {1<<kSDPLocalIdentityBit}
  196.  
  197.  
  198. TYPE
  199. SDPIdentityKind = INTEGER;
  200.  
  201. CONST
  202. kSDPSuggestionOnly = 0;
  203. kSDPRestrictToDirectory = 1;
  204. kSDPRestrictToRecord = 2;
  205.  
  206. TYPE
  207. SDPLoginFilterKind = INTEGER;
  208.  
  209.  
  210.  
  211.  
  212. { Panel Structures }
  213.  
  214. {
  215. While the panel is in operation, four selection states may exist.
  216.     1) kSDPNothingSelected means nothing is selected.
  217.     2) kContainSelected means a volume, folder, directory, dnode, or PAB is selected.
  218.     3) kSDPLockedContainerSelected means one of the above, but no access privledges.
  219.     4) kSDPRecordSelected means that a record is currently selected.
  220. }
  221.  
  222. CONST
  223. { Values of SDPSelectionState }
  224. kSDPNothingSelected = 0;
  225. kSDPLockedContainerSelected = 1;
  226. kSDPContainerSelected = 2;
  227. kSDPRecordSelected = 3;
  228. kSDPRecordAliasSelected = 4;
  229. kSDPContainerAliasSelected = 5;
  230.  
  231. TYPE
  232. SDPSelectionState = INTEGER;
  233.  
  234.  
  235.  
  236.  
  237. {
  238. This type informs the caller of the action the user took, either as the result
  239. of an event (as returned by SDPPanelEvent) or when SDPOpenSelectedItem is called.
  240.  
  241. kSDPProcessed means that the event (or call to SDPOpenSelectedItem) resulted in no
  242. state change.
  243.  
  244. kSDPSelectedAnItem indicates that the user wants to select the currently-hilited
  245. record. This is returned, for example, when a user double-clicks on a record.
  246.  
  247. kSDPChangedSelection implies that the user clicked on a new item (which may mean
  248. that no item is selected).
  249. }
  250.  
  251. CONST
  252. { Values of SDPPanelState }
  253. kSDPProcessed = 0;
  254. kSDPSelectedAnItem = 1;
  255. kSDPChangedSelection = 2;
  256.  
  257. TYPE
  258. SDPPanelState = INTEGER;
  259.  
  260.  
  261. {
  262. Your application may read any of the fields in a SDPPanelRecord, but it should
  263. use the appropriate routines to make changes to the records with the exception
  264. of the refCon field which your application may read or write at will.  Private
  265. information follows the SDPPanelRecord, so the handle must not be re-sized.
  266. }
  267.  
  268. SDPPanelRecord = RECORD
  269.     bounds: Rect;
  270.     visible: BOOLEAN;
  271.     enabled: BOOLEAN;
  272.     focused: BOOLEAN;
  273.     {padByte: Byte;}
  274.     identity: AuthIdentity;
  275.     refCon: LONGINT;
  276.     listRect: Rect;
  277.     popupRect: Rect;
  278.     numberOfRows: INTEGER;
  279.     rowHeight: INTEGER;
  280.     pabMode: BOOLEAN;
  281.     END;
  282.  
  283.  
  284. SDPPanelPtr = ^SDPPanelRecord;
  285. SDPPanelHandle = ^SDPPanelPtr;
  286.  
  287. PanelBusyProc = ProcPtr;
  288.     { PROCEDURE PanelBusyProc(Panel: SDPPanelHandle; busy: BOOLEAN); }
  289.  
  290.  
  291.  
  292.  
  293.  
  294. { Find Panel Structures }
  295. CONST
  296. kSDPItemIsSelectedBit = 0;
  297. kSDPFindTextExistsBit = 1;
  298. { Values of SDPFindPanelState }
  299. kSDPItemIsSelectedMask = $0001;  {1<<kSDPItemIsSelectedBit}
  300. kSDPFindTextExistsMask = $0002;  {1<<kSDPFindTextExistsBit}
  301.  
  302.  
  303. TYPE
  304. SDPFindPanelState = INTEGER;
  305.  
  306.  
  307. { Values of SDPFindPanelFocus }
  308. CONST
  309. kSDPFindPanelNoFocus = 0;
  310. kSDPFindPanelListHasFocus = 1;
  311. kSDPFindPanelTextHasFocus = 2;
  312.  
  313.  
  314. TYPE
  315. SDPFindPanelFocus = INTEGER;
  316.  
  317.  
  318. SDPFindPanelRecord = RECORD
  319.     upperLeft: Point;
  320.     visible: BOOLEAN;
  321.     enabled: BOOLEAN;
  322.     nowFinding: BOOLEAN;
  323.     {padByte: Byte;}
  324.     currentFocus: SDPFindPanelFocus;
  325.     identity: AuthIdentity;
  326.     simultaneousSearchCount: INTEGER;
  327.     refCon: LONGINT;
  328.     END;
  329.  
  330.  
  331. SDPFindPanelPtr = ^SDPFindPanelRecord;
  332. SDPFindPanelHandle = ^SDPFindPanelPtr;
  333.  
  334.  
  335. CONST
  336. { Values of SDPFindPanelResult }
  337. kSDPSelectedAFindItem = 0;
  338. kSDPFindSelectionChanged = 1;
  339. kSDPFindCompleted = 2;
  340. kSDPTextStateChanged = 3;
  341. kSDPFocusChanged = 4;
  342. kSDPSelectionAndFocusChanged = 5;
  343. kSDPMenuChanged = 6;
  344. kSDPSelectionAndMenuChanged = 7;
  345. kSDPProcessedFind = 8;
  346.  
  347. TYPE
  348. SDPFindPanelResult = INTEGER;
  349.  
  350.  
  351. PackedRStringListHandle = ^PackedPathNamePtr;
  352.  
  353. PackedDSSpecHandle = ^PackedDSSpecPtr;
  354.  
  355. FindPanelBusyProc = ProcPtr;
  356.     {PROCEDURE FindPanelBusyProc(findPanel: SDPFindPanelHandle; busy: BOOLEAN); }
  357.  
  358.  
  359. { Prompt For Identity Routines }
  360.  
  361.  
  362. FUNCTION SDPPromptForID(VAR id: AuthIdentity;
  363.                         guestPrompt: StringPtr;
  364.                         specificIDPrompt: StringPtr;
  365.                         localIDPrompt: StringPtr;
  366.                         recordType: RStringPtr;
  367.                         permittedKinds: SDPIdentityKind;
  368.                         VAR selectedKind: SDPIdentityKind;
  369.                         loginFilter: RecordIDPtr;
  370.                         filterKind: SDPLoginFilterKind): OSErr;
  371.     INLINE $203C, 16, kSDPPromptForID, $AA5D;
  372.  
  373.  
  374.  
  375. {
  376. SDPNewPanel creates a new panel. You supply the window in which the panel
  377. is to live, the bounds for the panel (which includes both the menu and the list),
  378. whether or not the panel is to be initially visible, the initial RLI (nil for
  379. directories and volumes), the types of records that will be shown (only a single
  380. (non-nil) type which may contain wildcards), the identity by which to browse
  381. (for access control reasons), and a refCon which is  available to the caller.
  382. }
  383. FUNCTION SDPNewPanel(VAR newPanel: SDPPanelHandle;
  384.                         window: WindowPtr;
  385.                         bounds: Rect;
  386.                         visible: BOOLEAN;
  387.                         enabled: BOOLEAN;
  388.                         initialRLI: PackedRLIPtr;
  389.                         typesList: RStringHandle;
  390.                         typeCount: LONGINT;
  391.                         identity: AuthIdentity;
  392.                         enumFlags: DirEnumChoices;
  393.                         matchTypeHow: SDPMatchWith;
  394.                         refCon: LONGINT): OSErr;
  395.     INLINE $203C, 21, kSDPNewPanel, $AA5D;
  396.  
  397.  
  398. {
  399. SDPSetIdentity Sets the identity used for browsing.
  400. }
  401. FUNCTION SDPSetIdentity(panel: SDPPanelHandle; identity: AuthIdentity): OSErr;
  402. INLINE $203C, 4, kSDPSetIdentity, $AA5D;
  403.  
  404.  
  405.  
  406.  
  407. {
  408. SDPGetNewPanel is similar to SDPNewPanel above, except it takes a resource id of a
  409. 'panl' resource.
  410. }
  411. FUNCTION SDPGetNewPanel(VAR newPanel: SDPPanelHandle;
  412.                             resourceID: INTEGER;
  413.                             window: WindowPtr;
  414.                             initialRLI: PackedRLIPtr;
  415.                             identity: AuthIdentity): OSErr;
  416.     INLINE $203C, 9, kSDPGetNewPanel, $AA5D;
  417.  
  418.  
  419. {
  420. Call this when you're completely done with a panel. It deallocates all of the
  421. associated data structures.
  422. }
  423. FUNCTION SDPDisposePanel(panel: SDPPanelHandle): OSErr;
  424.     INLINE $203C, 2, kSDPDisposePanel, $AA5D;
  425.  
  426.  
  427. {
  428. If the panel is visible, it makes it invisible by hiding the menu, turning off
  429. drawing of the list, and erasing and  invaling the list's rectangle.
  430. }
  431. FUNCTION SDPHidePanel(panel: SDPPanelHandle): OSErr;
  432.     INLINE $203C, 2, kSDPHidePanel, $AA5D;
  433.  
  434.  
  435. { If the panel is invisible, it makes it visible and draws it. }
  436.  
  437. FUNCTION SDPShowPanel(panel: SDPPanelHandle): OSErr;
  438.     INLINE $203C, 2, kSDPShowPanel, $AA5D;
  439.  
  440.  
  441. { Disables the list and menu so that it won't accept any commands. }
  442.  
  443. FUNCTION SDPEnablePanel(panel: SDPPanelHandle; enable: BOOLEAN): OSErr;
  444.     INLINE $203C, 3, kSDPEnablePanel, $AA5D;
  445.  
  446. {
  447. Move the upper-left-hand corner of the panel to (h, v), given in local coordinates of
  448. the panel's window.
  449. }
  450. FUNCTION SDPMovePanel(panel: SDPPanelHandle; h: INTEGER; v: INTEGER): OSErr;
  451.     INLINE $203C, 4, kSDPMovePanel, $AA5D;
  452.  
  453.  
  454. {
  455. Resizes the panel to have the given width and height (keeping the upper-left-hand
  456. corner in a fixed position).
  457. }
  458. FUNCTION SDPSizePanel(panel: SDPPanelHandle; width: INTEGER; height: INTEGER): OSErr;
  459.     INLINE $203C, 4, kSDPSizePanel, $AA5D;
  460.  
  461.  
  462. {
  463. This routine simulates a double-click on the selected item (if there is no selected
  464. item, then it does nothing), and it returns the result of that "double-click" via the
  465. whatHappened parameter. If a container is selected, then that container will be
  466. opened and kMovedDownTheHierarchy is returned. If, however, the user is at the lowest
  467. level in the hierarchy, then kSDPSelectedAnItem is returned.
  468. }
  469. FUNCTION SDPOpenSelectedItem(panel: SDPPanelHandle; VAR whatHappened: SDPPanelState): OSErr;
  470.     INLINE $203C, 4, kSDPOpenSelectedItem, $AA5D;
  471.  
  472.  
  473. {
  474. Returns whether a record is selected, something else is selected, or nothing is
  475. selected.
  476. }
  477. FUNCTION SDPGetPanelSelectionState(panel: SDPPanelHandle; VAR itsState: SDPSelectionState): OSErr;
  478.     INLINE $203C, 4, kSDPGetPanelSelectionState, $AA5D;
  479.  
  480.  
  481. {
  482. Returns the size of the currently-selected DSSpec, or zero if a record is
  483. not selected.  It is safe to do a NewPtr (SDPGetPanelSelectionSize (...))
  484. }
  485. FUNCTION SDPGetPanelSelectionSize(panel: SDPPanelHandle; VAR dsSpecSize: INTEGER): OSErr;
  486.     INLINE $203C, 4, kSDPGetPanelSelectionSize, $AA5D;
  487.  
  488.  
  489. {
  490. Returns the currently-selected DSSpec, or a zero-lengthed
  491. DSSpec if a record is not selected. It is assumed that the selection
  492. buffer allocated is large enough.
  493. }
  494. FUNCTION SDPGetPanelSelection(panel: SDPPanelHandle; selection: PackedDSSpecPtr): OSErr;
  495.     INLINE $203C, 4, kSDPGetPanelSelection, $AA5D;
  496.  
  497.  
  498. {
  499. Forces browsing to the specified RLI. If prli is the current RLI, then it does
  500. nothing.
  501. }
  502. FUNCTION SDPSetPath(panel: SDPPanelHandle; prli: PackedRLIPtr): OSErr;
  503.     INLINE $203C, 4, kSDPSetPath, $AA5D;
  504.  
  505.  
  506. {
  507. This is the main driver for the panel.  You should pass all events to SDPPanelEvent
  508. including NULL events.  If you have more than 1 panel, you will need to
  509. call SDPPanelEvent for each panel.  NOTE:  For Update Events you will also need to call
  510. SDPUpdatePanel as described below.
  511. }
  512. FUNCTION SDPPanelEvent(panel: SDPPanelHandle;
  513.                             theEvent: EventRecord;
  514.                             VAR whatHappened: SDPPanelState): OSErr;
  515.     INLINE $203C, 6, kSDPPanelEvent, $AA5D;
  516.  
  517.  
  518.  
  519. {
  520. SDPUpdatePanel should be called in response to an update event.  Generally you will
  521. have first called BeginUpdate, and pass the windows visRgn as theRgn.  If NULL
  522. is passed for theRgn the entire panel is re-drawn.  NOTE:  Drawing is not cliped to
  523. theRgn, if this is desired, you must first call SetClip.
  524. }
  525. FUNCTION SDPUpdatePanel(panel: SDPPanelHandle; theRgn: RgnHandle): OSErr;
  526.     INLINE $203C, 4, kSDPUpdatePanel, $AA5D;
  527.  
  528.  
  529. {
  530. SDPSelectString scrolls and selects the closest matching string at the current
  531. level.  This is the same behavior as if the user typed in the given string.
  532. }
  533. FUNCTION SDPSelectString(panel: SDPPanelHandle; name: RStringPtr): OSErr;
  534.     INLINE $203C, 4, kSDPSelectString, $AA5D;
  535.  
  536. {
  537. SDPGetPathLength returns the length in bytes required to hold the current path name
  538. in RLI format.  This corresponds to the path name in the popup menu.
  539. }
  540. FUNCTION SDPGetPathLength(panel: SDPPanelHandle; VAR pathNameLength: INTEGER): OSErr;
  541.     INLINE $203C, 4, kSDPGetPathLength, $AA5D;
  542.  
  543. { SDPGetPath returns the current rli. }
  544. FUNCTION SDPGetPath(panel: SDPPanelHandle; prli: PackedRLIPtr; VAR dsRefNum: INTEGER): OSErr;
  545.     INLINE $203C, 6, kSDPGetPath, $AA5D;
  546.  
  547. {
  548. SDPSetFocus will draw the focus rectangle or erase the focus rectangle depending upon
  549. the focus boolean.
  550. }
  551. FUNCTION SDPSetFocus(panel: SDPPanelHandle; focus: BOOLEAN): OSErr;
  552.     INLINE $203C, 3, kSDPSetFocus, $AA5D;
  553.  
  554. {
  555. SDPSetPanelBalloonHelp allows clients to specify a STR# resource id to use for
  556. balloon help.  Balloon help is unavailable until this call is made.
  557. }
  558. FUNCTION SDPSetPanelBalloonHelp(panel: SDPPanelHandle; balloonHelpID: INTEGER): OSErr;
  559.     INLINE $203C, 3, kSDPSetPanelBalloonHelp, $AA5D;
  560.  
  561. {
  562. SDPInstallPanelBusyProc allows clients to install a CB that will be called while
  563. the panel is aynchronously busy.
  564. }
  565. FUNCTION SDPInstallPanelBusyProc(panel: SDPPanelHandle; busyProc: PanelBusyProc): OSErr;
  566.     INLINE $203C, 4, kSDPInstallPanelBusyProc, $AA5D;
  567.  
  568.  
  569.  
  570. FUNCTION SDPNewFindPanel(VAR newPanel: SDPFindPanelHandle; window: WindowPtr;
  571.     upperLeft: Point; layoutResourceID: INTEGER; visible: BOOLEAN;
  572.     enabled: BOOLEAN; typesList: RStringHandle;  typeCount: LONGINT;
  573.     matchTypeHow: SDPMatchWith; identity: AuthIdentity; simultaneousSearchCount: INTEGER;
  574.     initialFocus: SDPFindPanelFocus; refCon: LONGINT): OSErr;
  575.     INLINE $203C, 20, kSDPNewFindPanel, $AA5D;
  576.  
  577. FUNCTION SDPDisposeFindPanel(findPanel: SDPFindPanelHandle): OSErr;
  578.     INLINE $203C, 2, kSDPDisposeFindPanel, $AA5D;
  579.  
  580. FUNCTION SDPStartFind(findPanel: SDPFindPanelHandle): OSErr;
  581.     INLINE $203C, 2, kSDPStartFind, $AA5D;
  582.  
  583. FUNCTION SDPStopFind(findPanel: SDPFindPanelHandle): OSErr;
  584.     INLINE $203C, 2, kSDPStopFind, $AA5D;
  585.  
  586. FUNCTION SDPFindPanelEvent(findPanel: SDPFindPanelHandle;
  587.     event: EventRecord; VAR whatHappened: SDPFindPanelResult): OSErr;
  588.     INLINE $203C, 6, kSDPFindPanelEvent, $AA5D;
  589.  
  590. FUNCTION SDPUpdateFindPanel(findPanel: SDPFindPanelHandle; theRgn: RgnHandle): OSErr;
  591.     INLINE $203C, 4, kSDPDrawFindPanel, $AA5D;
  592.  
  593. FUNCTION SDPShowFindPanel(findPanel: SDPFindPanelHandle): OSErr;
  594.     INLINE $203C, 2, kSDPShowFindPanel, $AA5D;
  595.  
  596. FUNCTION SDPHideFindPanel(findPanel: SDPFindPanelHandle): OSErr;
  597.     INLINE $203C, 2, kSDPHideFindPanel, $AA5D;
  598.  
  599. FUNCTION SDPMoveFindPanel(findPanel: SDPFindPanelHandle; h: INTEGER; v: INTEGER): OSErr;
  600.     INLINE $203C, 4, kSDPMoveFindPanel, $AA5D;
  601.  
  602. FUNCTION SDPEnableFindPanel(findPanel: SDPFindPanelHandle; enabled: BOOLEAN): OSErr;
  603.     INLINE $203C, 3, kSDPEnableFindPanel, $AA5D;
  604.  
  605. FUNCTION SDPSetFindPanelFocus(findPanel: SDPFindPanelHandle;
  606.     newFocus: SDPFindPanelFocus): OSErr;
  607.     INLINE $203C, 3, kSDPSetFindPanelFocus, $AA5D;
  608.  
  609. FUNCTION SDPGetFindPanelState(findPanel: SDPFindPanelHandle; VAR itsState: SDPFindPanelState): OSErr;
  610.     INLINE $203C, 4, kSDPGetFindPanelState, $AA5D;
  611.  
  612. FUNCTION SDPGetFindPanelSelectionSize(findPanel: SDPFindPanelHandle;
  613.     VAR size: INTEGER): OSErr;
  614.     INLINE $203C, 4, kSDPGetFindPanelSelectionSize, $AA5D;
  615.  
  616. FUNCTION SDPGetFindPanelSelection(findPanel: SDPFindPanelHandle;
  617.     selection: PackedDSSpecPtr): OSErr;
  618.     INLINE $203C, 4, kSDPGetFindPanelSelection, $AA5D;
  619.  
  620. FUNCTION SDPSetFindPanelBalloonHelp(findPanel: SDPFindPanelHandle;
  621.     balloonHelpID: INTEGER): OSErr;
  622.     INLINE $203C, 3, kSDPSetFindPanelBalloonHelp, $AA5D;
  623.  
  624. FUNCTION SDPSetFindIdentity(findPanel: SDPFindPanelHandle;
  625.     identity: AuthIdentity): OSErr;
  626.     INLINE $203C, 4, kSDPSetFindIdentity, $AA5D;
  627.  
  628. FUNCTION SDPInstallFindPanelBusyProc(findPanel: SDPFindPanelHandle; busyProc: FindPanelBusyProc): OSErr;
  629.     INLINE $203C, 4, kSDPInstallFindPanelBusyProc, $AA5D;
  630.  
  631.  
  632.  
  633. FUNCTION SDPGetIconByType(recordType: RStringPtr;
  634.                               whichIcons: IconSelectorValue;
  635.                               VAR iconSuite: Handle): OSErr;
  636.                               INLINE $303C, kSDPGetIconByType, $AA5C;
  637.  
  638. FUNCTION SDPGetDSSpecIcon(packedDSSpec: PackedDSSpecPtr;
  639.                               whichIcons: IconSelectorValue;
  640.                               VAR iconSuite: Handle): OSErr;
  641.                               INLINE $303C, kSDPGetDSSpecIcon, $AA5C;
  642.  
  643. FUNCTION SDPGetCategories(VAR catagories: PackedRStringListHandle;
  644.                           VAR displayNames: PackedRStringListHandle): OSErr;
  645.                               INLINE $303C, kSDPGetCategories, $AA5C;
  646.  
  647. FUNCTION SDPGetCategoryTypes(category: RStringPtr;
  648.                                  VAR types: PackedRStringListHandle): OSErr;
  649.                                  INLINE $303C, kSDPGetCategoryTypes, $AA5C;
  650.  
  651.  
  652.  
  653. FUNCTION SDPResolveAliasFile(fileSpec: FSSpecPtr;
  654.                                  resolvedDSSpec: PackedDSSpecHandle;
  655.                                  identity: AuthIdentity;
  656.                                  mayPromptUser: BOOLEAN): OSErr;
  657.                     INLINE $203C, 7, kSDPResolveAliasFile, $AA5D;
  658.  
  659. FUNCTION SDPResolveAliasDSSpec(theAliasDSSpec: PackedDSSpecHandle;
  660.                                    identity: AuthIdentity;
  661.                                    mayPromptUser: BOOLEAN): OSErr;
  662.                     INLINE $203C, 5, kSDPResolveAliasDSSpec, $AA5D;
  663.  
  664. FUNCTION SDPRepairPersonalDirectory(pd: FSSpecPtr; showProgress: BOOLEAN): OSErr;
  665.                     INLINE $203C, 3, kSDPRepairPersonalDirectory, $AA5D;
  666.  
  667.  
  668.  
  669. {$ENDC}    { UsingOCEStandardDirectory }
  670.  
  671. {$IFC NOT UsingIncludes}
  672.     END.
  673. {$ENDC}
  674.